name: MetricDescriptor
type: MetricDescriptor
description: |
    Defines a metric type and its schema. Once a metric descriptor is created,
     deleting or altering it stops data collection and makes the metric type's
     existing data unusable.
__proto:
    package: google.api
    targetfile: metric.proto
    imports:
        - google/api/label.proto
        - google/api/launch_stage.proto
        - google/protobuf/duration.proto
    options:
        go_package: google.golang.org/genproto/googleapis/api/metric;metric
        java_multiple_files: "true"
        java_outer_classname: MetricProto
        java_package: com.google.api
        objc_class_prefix: GAPI
fields:
    name:
        type: string
        description: The resource name of the metric descriptor.
        __proto:
            number: 1
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.name
            options:
                flags: []
                list: []
            readonly: false
            repeated: false
            typespecific: null
        constraints: {}
    type:
        type: string
        description: |-
            The metric type, including its DNS name prefix. The type is not
             URL-encoded. All user-defined metric types have the DNS name
             `custom.googleapis.com` or `external.googleapis.com`. Metric types should
             use a natural hierarchical grouping. For example:

                 "custom.googleapis.com/invoice/paid/amount"
                 "external.googleapis.com/prometheus/up"
                 "appengine.googleapis.com/http/server/response_latencies"
        __proto:
            number: 8
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.type
            options:
                flags: []
                list: []
            readonly: false
            repeated: false
            typespecific: null
        constraints: {}
    labels:
        type: google.api.LabelDescriptor
        description: |-
            The set of labels that can be used to describe a specific
             instance of this metric type. For example, the
             `appengine.googleapis.com/http/server/response_latencies` metric
             type has a label for the HTTP response code, `response_code`, so
             you can look at latencies for successful responses or just
             for responses that failed.
        __proto:
            number: 2
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.labels
            options:
                flags: []
                list: []
            readonly: false
            repeated: true
            typespecific: null
        constraints: {}
    metric_kind:
        type: unknown
        description: |-
            Whether the metric records instantaneous values, changes to a value, etc.
             Some combinations of `metric_kind` and `value_type` might not be supported.
        __proto:
            number: 3
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.metric_kind
            options:
                flags: []
                list: []
            readonly: false
            repeated: false
            typespecific: null
        constraints: {}
    value_type:
        type: unknown
        description: |-
            Whether the measurement is an integer, a floating-point number, etc.
             Some combinations of `metric_kind` and `value_type` might not be supported.
        __proto:
            number: 4
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.value_type
            options:
                flags: []
                list: []
            readonly: false
            repeated: false
            typespecific: null
        constraints: {}
    unit:
        type: string
        description: |-
            The units in which the metric value is reported. It is only applicable
             if the `value_type` is `INT64`, `DOUBLE`, or `DISTRIBUTION`. The `unit`
             defines the representation of the stored metric values.

             Different systems may scale the values to be more easily displayed (so a
             value of `0.02KBy` _might_ be displayed as `20By`, and a value of
             `3523KBy` _might_ be displayed as `3.5MBy`). However, if the `unit` is
             `KBy`, then the value of the metric is always in thousands of bytes, no
             matter how it may be displayed..

             If you want a custom metric to record the exact number of CPU-seconds used
             by a job, you can create an `INT64 CUMULATIVE` metric whose `unit` is
             `s{CPU}` (or equivalently `1s{CPU}` or just `s`). If the job uses 12,005
             CPU-seconds, then the value is written as `12005`.

             Alternatively, if you want a custom metric to record data in a more
             granular way, you can create a `DOUBLE CUMULATIVE` metric whose `unit` is
             `ks{CPU}`, and then write the value `12.005` (which is `12005/1000`),
             or use `Kis{CPU}` and write `11.723` (which is `12005/1024`).

             The supported units are a subset of [The Unified Code for Units of
             Measure](http://unitsofmeasure.org/ucum.html) standard:

             **Basic units (UNIT)**

             * `bit`   bit
             * `By`    byte
             * `s`     second
             * `min`   minute
             * `h`     hour
             * `d`     day
             * `1`     dimensionless

             **Prefixes (PREFIX)**

             * `k`     kilo    (10^3)
             * `M`     mega    (10^6)
             * `G`     giga    (10^9)
             * `T`     tera    (10^12)
             * `P`     peta    (10^15)
             * `E`     exa     (10^18)
             * `Z`     zetta   (10^21)
             * `Y`     yotta   (10^24)

             * `m`     milli   (10^-3)
             * `u`     micro   (10^-6)
             * `n`     nano    (10^-9)
             * `p`     pico    (10^-12)
             * `f`     femto   (10^-15)
             * `a`     atto    (10^-18)
             * `z`     zepto   (10^-21)
             * `y`     yocto   (10^-24)

             * `Ki`    kibi    (2^10)
             * `Mi`    mebi    (2^20)
             * `Gi`    gibi    (2^30)
             * `Ti`    tebi    (2^40)
             * `Pi`    pebi    (2^50)

             **Grammar**

             The grammar also includes these connectors:

             * `/`    division or ratio (as an infix operator). For examples,
                      `kBy/{email}` or `MiBy/10ms` (although you should almost never
                      have `/s` in a metric `unit`; rates should always be computed at
                      query time from the underlying cumulative or delta value).
             * `.`    multiplication or composition (as an infix operator). For
                      examples, `GBy.d` or `k{watt}.h`.

             The grammar for a unit is as follows:

                 Expression = Component { "." Component } { "/" Component } ;

                 Component = ( [ PREFIX ] UNIT | "%" ) [ Annotation ]
                           | Annotation
                           | "1"
                           ;

                 Annotation = "{" NAME "}" ;

             Notes:

             * `Annotation` is just a comment if it follows a `UNIT`. If the annotation
                is used alone, then the unit is equivalent to `1`. For examples,
                `{request}/s == 1/s`, `By{transmitted}/s == By/s`.
             * `NAME` is a sequence of non-blank printable ASCII characters not
                containing `{` or `}`.
             * `1` represents a unitary [dimensionless
                unit](https://en.wikipedia.org/wiki/Dimensionless_quantity) of 1, such
                as in `1/s`. It is typically used when none of the basic units are
                appropriate. For example, "new users per day" can be represented as
                `1/d` or `{new-users}/d` (and a metric value `5` would mean "5 new
                users). Alternatively, "thousands of page views per day" would be
                represented as `1000/d` or `k1/d` or `k{page_views}/d` (and a metric
                value of `5.3` would mean "5300 page views per day").
             * `%` represents dimensionless value of 1/100, and annotates values giving
                a percentage (so the metric values are typically in the range of 0..100,
                and a metric value `3` means "3 percent").
             * `10^2.%` indicates a metric contains a ratio, typically in the range
                0..1, that will be multiplied by 100 and displayed as a percentage
                (so a metric value `0.03` means "3 percent").
        __proto:
            number: 5
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.unit
            options:
                flags: []
                list: []
            readonly: false
            repeated: false
            typespecific: null
        constraints: {}
    description:
        type: string
        description: A detailed description of the metric, which can be used in documentation.
        __proto:
            number: 6
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.description
            options:
                flags: []
                list: []
            readonly: false
            repeated: false
            typespecific: null
        constraints: {}
    display_name:
        type: string
        description: |-
            A concise name for the metric, which can be displayed in user interfaces.
             Use sentence case without an ending period, for example "Request count".
             This field is optional but it is recommended to be set for any metrics
             associated with user-visible concepts, such as Quota.
        __proto:
            number: 7
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.display_name
            options:
                flags: []
                list: []
            readonly: false
            repeated: false
            typespecific: null
        constraints: {}
    metadata:
        type: google.api.MetricDescriptor.MetricDescriptorMetadata
        description: Optional. Metadata which can be used to guide usage of the metric.
        __proto:
            number: 10
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.metadata
            options:
                flags: []
                list: []
            readonly: false
            repeated: false
            typespecific: null
        constraints: {}
    launch_stage:
        type: unknown
        description: Optional. The launch stage of the metric definition.
        __proto:
            number: 12
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.launch_stage
            options:
                flags: []
                list: []
            readonly: false
            repeated: false
            typespecific: null
        constraints: {}
    monitored_resource_types:
        type: string
        description: |-
            Read-only. If present, then a [time
             series][google.monitoring.v3.TimeSeries], which is identified partially by
             a metric type and a [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor], that is associated
             with this metric type can only be associated with one of the monitored
             resource types listed here.
        __proto:
            number: 13
            oneof: ""
        __ui:
            component: ""
            flags: []
            noinit: false
            noskip: false
        meta:
            default: ""
            hint: ""
            label: label.MetricDescriptor.monitored_resource_types
            options:
                flags: []
                list: []
            readonly: false
            repeated: true
            typespecific: null
        constraints: {}
